#include "Utils.h"
#include "customtablewidgetitem.h"
#include "qcheckbox.h"
#include "qheaderview.h"
#include "qmessagebox.h"
#include <QTableWidgetItem>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonValue>
#include <QDebug>
#include <QUrl>
#include <qeventloop.h>

void Utils::fetchDataFromApi(const QUrl &apiUrl, std::function<void(const QJsonDocument &)> callback)
{
    // 创建网络访问管理器
    QNetworkAccessManager *manager = new QNetworkAccessManager();

    // 创建网络请求
    QNetworkRequest request(apiUrl);

    // 发送 GET 请求
    QNetworkReply *reply = manager->get(request);

    // 处理响应
    QObject::connect(reply, &QNetworkReply::finished, [reply, callback]()
                     {
                         if (reply->error() == QNetworkReply::NoError)
                         {
                             // 获取响应数据
                             QByteArray response = reply->readAll();

                             // 解析 JSON 数据
                             QJsonDocument jsonDoc = QJsonDocument::fromJson(response);

                             if (!jsonDoc.isNull())
                             {
                                 // 通过回调函数返回解析后的 JSON 数据
                                 callback(jsonDoc);
                             }
                             else
                             {
                                 qDebug() << "JSON 解析失败";
                             }
                         }
                         else
                         {
                             // 处理请求错误
                             qDebug() << "请求错误: " << reply->errorString();
                         }

                         reply->deleteLater(); // 清理资源
                     });
}
/**
 *  用法示例
    // 第一步：#include "utils.h"

    // 第二步：设置要请求的 API URL
    QUrl apiUrl("http://localhost:5000/get_data");

    // 第三步：调用 fetchDataFromApi 函数
    Utils::fetchDataFromApi(apiUrl, [](const QJsonDocument &jsonDoc) {
        // 解析 JSON 数据
        if (jsonDoc.isObject()) {
            QJsonObject jsonObject = jsonDoc.object();

            // 打印结果
            qDebug() << "response:" << jsonObject;
        } else {
            qDebug() << "JSON 不是对象类型";
        }
    });
**/

void Utils::loadTableData(QTableWidget *table, const QVector<QVector<QString>> &data)
{
    // 清空现有表格内容
    table->clear();

    // 设置行数和列数
    int rowCount = data.size();
    int columnCount = rowCount > 0 ? data[0].size() : 0;
    table->setRowCount(rowCount);
    table->setColumnCount(columnCount);

    // 填充数据
    for (int row = 0; row < rowCount; ++row)
    {
        for (int column = 0; column < columnCount; ++column)
        {
            QTableWidgetItem *item = new QTableWidgetItem(data[row][column]);
            table->setItem(row, column, item);
        }
    }
}

/**
 * // 模拟一些数据
    QVector<QVector<QString>> data = {
        {"Name", "Age"},
        {"Alice", "30"},
        {"Bob", "25"},
        {"Charlie", "35"}
    };

    // 调用 loadTableData 函数填充表格
    Utils::loadTableData(table, data);

    // 设置表格大小并显示
    table->resize(400, 300);
    table->show();
**/

// POST请求，回调函数处理结果
void Utils::postDataToApi(const QUrl &apiUrl, const QJsonDocument &jsonData, std::function<void(const QJsonDocument &)> callback)
{
    // 创建网络访问管理器
    QNetworkAccessManager *manager = new QNetworkAccessManager();

    // 创建网络请求
    QNetworkRequest request(apiUrl);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

    // 发送 POST 请求
    QNetworkReply *reply = manager->post(request, jsonData.toJson());

    // 处理响应
    QObject::connect(reply, &QNetworkReply::finished, [reply, callback]()
                     {
                         if (reply->error() == QNetworkReply::NoError)
                         {
                             // 获取响应数据
                             QByteArray response = reply->readAll();

                             // 解析 JSON 数据
                             QJsonDocument jsonDoc = QJsonDocument::fromJson(response);

                             if (!jsonDoc.isNull())
                             {
                                 // 通过回调函数返回解析后的 JSON 数据
                                 callback(jsonDoc);
                             }
                             else
                             {
                                 qDebug() << "JSON 解析失败";
                             }
                         }
                         else
                         {
                             // 处理请求错误
                             qDebug() << "请求错误: " << reply->errorString();
                         }

                         reply->deleteLater(); // 清理资源
                     });
}

/**

QJsonDocument jsonData; // 填充你的 JSON 数据
Utils::postDataToApi(apiUrl, jsonData, [](const QJsonDocument &responseDoc) {
    // 处理响应
    qDebug() << "响应数据:" << responseDoc;
});

**/

void Utils::post_display(const QUrl &apiUrl, const QJsonDocument &jsonData)
{

    Utils::postDataToApi(apiUrl, jsonData, [=](const QJsonDocument &responseDoc)
                         {
        if (responseDoc.isObject()) {
            QJsonObject jsonObject = responseDoc.object();
            int code = jsonObject["code"].toInt();
            QString msg = jsonObject["msg"].toString();

            // 如果响应状态码为200，则
            if(jsonObject["code"].toInt() == 200)
            {
                QMessageBox::information(nullptr,"成功",msg,QMessageBox::Ok);
            }else
            {
                QMessageBox::critical(nullptr,"失败",msg,QMessageBox::Ok);
            }
        } else {
            QMessageBox::warning(nullptr, "错误", "响应不是对象类型");
        } });
}

// 获取已选择的表格内容（按行选、多选）
QVector<QVector<QString>> Utils::getSelectedRowsData(QTableWidget *tableWidget)
{
    QVector<QVector<QString>> selectedData;

    // 获取所有选中的项
    QList<QTableWidgetItem *> selectedItems = tableWidget->selectedItems();

    // 使用一个集合来避免重复行
    QSet<int> selectedRows;

    // 遍历选中的项，记录它们的行号
    for (QTableWidgetItem *item : selectedItems)
    {
        selectedRows.insert(item->row());
    }

    // 遍历所有选中的行
    for (int row : selectedRows)
    {
        QVector<QString> rowData;
        for (int column = 0; column < tableWidget->columnCount(); ++column)
        {
            QTableWidgetItem *item = tableWidget->item(row, column);
            if (item)
            {
                rowData.append(item->text());
            }
            else
            {
                rowData.append(""); // 如果没有项，添加空字符串
            }
        }
        selectedData.append(rowData);
    }

    return selectedData;
}

// 获取数据并加载到表格组件
// void Utils::fetchDataAndLoadTable(const QUrl &apiUrl, const QJsonDocument &jsonData, QTableWidget *table)
// {
//     postDataToApi(apiUrl, jsonData, [table](const QJsonDocument &responseDoc)
//                   {
//                       // 清空表格
//                       table->clear();
//                       table->setRowCount(0); // 重置行数
//                       table->setColumnCount(0); // 重置列数
//                       // table->horizontalHeader()->setVisible(false); // 隐藏表头

//                       table->setSortingEnabled(true); // 在初始化表格后启用排序

//                       // 处理响应
//                       if (responseDoc.isObject()) {
//                           QJsonObject jsonObject = responseDoc.object();
//                           if (jsonObject.contains("data") && jsonObject["data"].isArray()) {
//                               QJsonArray jsonArray = jsonObject["data"].toArray();

//                               // 获取第一个数据的键作为表头
//                               if (!jsonArray.isEmpty()) {
//                                   QJsonObject firstObj = jsonArray[0].toObject();
//                                   QStringList header;

//                                   for (const QString &key : firstObj.keys()) {
//                                       header.append(key);
//                                   }
//                                   // 设置表头
//                                   table->setColumnCount(header.size());
//                                   table->setHorizontalHeaderLabels(header);

//                                   // 遍历数据并添加行
//                                   for (const QJsonValue &value : jsonArray) {
//                                       QJsonObject obj = value.toObject();
//                                       int row = table->rowCount();
//                                       table->insertRow(row); // 插入新行

//                                       for (int col = 0; col < header.size(); ++col) {
//                                           const QString &key = header[col];
//                                           CustomTableWidgetItem *item;

//                                           if (obj.contains(key) && !obj[key].isNull()) { // 检查字段是否存在且不为空
//                                               if (obj[key].isDouble()) {
//                                                   item = new CustomTableWidgetItem(QString::number(obj[key].toDouble()));
//                                               } else if (obj[key].isString()) {
//                                                   item = new CustomTableWidgetItem(obj[key].toString());
//                                               } else if (obj[key].isDouble()) {
//                                                   item = new CustomTableWidgetItem(obj[key].toInt());
//                                               } else {
//                                                   item = new CustomTableWidgetItem(""); // 设置为空字符串
//                                               }
//                                           } else {
//                                               item = new CustomTableWidgetItem(""); // 设置为空字符串
//                                           }

//                                           // 设置内容居中显示
//                                           item->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
//                                           table->setItem(row, col, item);
//                                       }
//                                   }

//                               } else {
//                                   qDebug() << "数据数组为空";
//                               }
//                           } else {
//                               qDebug() << "响应中没有数据字段或数据字段不是数组类型";
//                           }
//                       } else {
//                           qDebug() << "响应不是对象类型";
//                       }

//                       // 设置表格大小并显示
//                       table->resize(400, 300);
//                       table->show();
//                   });
// }

/**

调用示例
QUrl apiUrl("http://192.168.5.69:5000/get_move_history_data");
QJsonObject jsonObj;
jsonObj["limit"] = 100; // 例如，传递 limit 参数
QJsonDocument jsonData(jsonObj);
Utils::fetchDataAndLoadTable(apiUrl, jsonData, table);

解析 JSON 响应并根据第一个元素的键动态生成表头。
将解析后的数据加载到指定的 QTableWidget 中。
响应数据格式如下：
{
    "code": 200,
    "data": [
        {
            "ID": 4,
            "储位": "01021",
            "创建人": "1.0",
            "创建时间": "Tue, 10 Sep 2024 13:34:08 GMT"
        },
        {
            "ID": 1,
            "储位": "01011",
            "创建人": "1.0",
            "创建时间": "Sat, 07 Sep 2024 13:40:15 GMT"
        },
        {
            "ID": 5,
            "储位": "01012",
            "创建人": "1.0",
            "创建时间": "Sat, 07 Sep 2024 13:40:15 GMT"
        }
    ]
}
 **/

// 定制化解析数据
void Utils::fetchDataAndLoadTable(const QUrl &apiUrl, const QJsonDocument &jsonData, QTableWidget *table)
{
    Utils::postDataToApi(apiUrl, jsonData, [table](const QJsonDocument &responseDoc)
                         {
                      // 清空表格
                      table->clear();
                      table->setRowCount(0); // 重置行数
                      table->setColumnCount(0); // 重置列数
                      table->setSortingEnabled(true); // 启用排序
                      // 设置表格内容自适应宽度
                      table->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);

                      // 处理响应
                      if (responseDoc.isObject())
                      {
                          QJsonObject jsonObject = responseDoc.object();

                          // 开始解析表头数据，设置表头
                          if (jsonObject["code"].toInt() == 200)
                          {
                              // 获取 "data" 对象
                              QJsonObject dataObj = jsonObject["data"].toObject();

                              // 解析 "keys" 数组，作为表头
                              QJsonArray keysArray = dataObj["keys"].toArray();
                              table->setColumnCount(keysArray.size()); // 设置列数
                              QStringList headers;
                              for (const QJsonValue &key : keysArray)
                              {
                                  QJsonObject keyObj = key.toObject();
                                  QString keyName = keyObj.keys().first(); // 获取键
                                  QString keyValue = keyObj[keyName].toString(); // 获取值，作为表头
                                  headers << keyValue;
                              }
                              table->setHorizontalHeaderLabels(headers); // 设置表头

                              // 解析 "values" 数组并添加到表格中
                              QJsonArray valuesArray = dataObj["values"].toArray();

                              // 遍历数据并添加行
                              for (const QJsonValue &value : valuesArray) {
                                  QJsonObject obj = value.toObject();
                                  int row = table->rowCount();
                                  table->insertRow(row); // 插入新行

                                  // 遍历 keys 并获取对应的值
                                  for (int col = 0; col < keysArray.size(); ++col) {
                                      QJsonObject keyObj = keysArray[col].toObject();
                                      QString keyName = keyObj.keys().first(); // 获取键名
                                      CustomTableWidgetItem *item;

                                      // 获取对应的值并设置到表格中
                                      if (obj.contains(keyName)) {
                                          if (obj[keyName].isDouble()) {
                                              item = new CustomTableWidgetItem(QString::number(obj[keyName].toDouble()));
                                          } else if (obj[keyName].isString()) {
                                              item = new CustomTableWidgetItem(obj[keyName].toString());
                                          } else {
                                              item = new CustomTableWidgetItem(""); // 如果为空或不匹配，设置为空字符串
                                          }
                                      } else {
                                          item = new CustomTableWidgetItem(""); // 如果没有匹配的字段，设置为空字符串
                                      }

                                      // 设置内容居中显示
                                      item->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
                                      table->setItem(row, col, item);
                                  }
                              }
                          }
                          else
                          {
                              qDebug() << "请求失败，错误码：" << jsonObject["code"].toInt();
                          }
                      }
                      else
                      {
                          qDebug() << "响应不是对象类型";
                      }

                      // 设置表格大小并显示
                      table->resize(400, 300);
                      table->show(); });
}

/**

调用示例
QUrl apiUrl("http://192.168.5.69:5000/get_move_history_data");
QJsonObject jsonObj;
jsonObj["limit"] = 100; // 例如，传递 limit 参数
QJsonDocument jsonData(jsonObj);
Utils::fetchDataAndLoadTable(apiUrl, jsonData, table);

解析 JSON 响应并根据第一个元素的键动态生成表头。
将解析后的数据加载到指定的 QTableWidget 中。
响应数据格式如下：
{
    "code": 200,
    "data": {
        "keys": {
            "id": "ID",
            "solder_sn": "锡膏序列号",
            "material_code": "料号",
            "brand": "品牌",
            "model": "型号",
            "lot_no": "批次号",
            "dc": "生产日期",
            "create_by": "创建人",
            "create_on": "创建时间",
            "weight": "重量",
            "location": "区域",
            "storage": "储位",
            "status": "状态",
            "writer": "操作人",
            "write_time": "操作时间",
            "location_time": "在区域时间",
            "action_status": "动作状态"
        },
        "values": {
            "id": 20,
            "solder_sn": "ET1727514020",
            "material_code": "WL004",
            "brand": "1",
            "model": "",
            "lot_no": "240903",
            "dc": "240903",
            "create_by": "",
            "create_on": "2024-09-28 17:18:07",
            "weight": 5000,
            "location": "冷藏区",
            "storage": "09036",
            "status": "冷藏区",
            "writer": "",
            "write_time": "2024-09-28 17:18:07",
            "location_time": "2024-09-28 17:18:07",
            "action_status": ""
        }
    }
}
 **/







// 检查是否选择了表格
bool Utils::hasSelectedRows(QTableWidget *tableWidget)
{
    return !tableWidget->selectedItems().isEmpty();
}

// 获取整个表格的数据并构建JSON参数返回(从第一行开始提取数据)
QJsonDocument Utils::getTableDataAsJson(QTableWidget *table)
{
    QJsonArray jsonArray;
    int rowCount = table->rowCount();

    // 确保表格不为空
    if (rowCount <= 0) // 修改为 <= 0，确保至少有一行数据
    {
        qDebug() << "表格为空，返回空的 JSON 文档"; // 调试信息
        return QJsonDocument();                     // 返回空的 JSON 文档
    }

    // 遍历每一行，从第一行开始，构建 JSON 对象
    for (int row = 0; row < rowCount; ++row) // 从第一行开始
    {
        QJsonObject jsonObject;

        QTableWidgetItem *speedItem = table->item(row, 0); // 假设第一列为 speed
        QTableWidgetItem *timeItem = table->item(row, 1);  // 假设第二列为 time

        // 获取 speed
        if (speedItem)
        {
            jsonObject["speed"] = speedItem->text();                     // 获取 speed
            qDebug() << "行" << row << "的 speed:" << speedItem->text(); // 调试信息
        }
        else
        {
            qDebug() << "行" << row << "的 speed 项不存在"; // 调试信息
        }

        // 获取 time
        if (timeItem)
        {
            jsonObject["time"] = timeItem->text();                     // 获取 time
            qDebug() << "行" << row << "的 time:" << timeItem->text(); // 调试信息
        }
        else
        {
            qDebug() << "行" << row << "的 time 项不存在"; // 调试信息
        }

        // 仅在 speed 和 time 存在时才添加到数组
        if (jsonObject.contains("speed") && jsonObject.contains("time"))
        {
            jsonArray.append(jsonObject);                          // 将行对象添加到数组
            qDebug() << "行" << row << "的数据已添加到 JSON 数组"; // 调试信息
        }
        else
        {
            qDebug() << "行" << row << "的数据不完整，未添加到 JSON 数组"; // 调试信息
        }
    }

    QJsonObject jsonData;
    jsonData["solder_speed"] = jsonArray;        // 外层结构
    qDebug() << "构建的 JSON 文档:" << jsonData; // 调试信息
    return QJsonDocument(jsonData);              // 返回构建的 JSON 文档
}


// 解析 jsonString => QJsonObject
QJsonObject Utils::parseJsonFromString(const QString& jsonString)
{
	QJsonObject jsonObject;

	QJsonParseError parseError;
	QJsonDocument jsonDocument = QJsonDocument::fromJson(jsonString.toUtf8(), &parseError);

	if (parseError.error == QJsonParseError::NoError && !jsonDocument.isNull() && jsonDocument.isObject())
	{
		jsonObject = jsonDocument.object();
	}
	else
	{
		qDebug() << "JSON parse error:" << parseError.errorString();
	}

	return jsonObject;
}
